---
title: Entry Functions
---

The `entry` modifier allows a function to be called directly from a programmable transaction block, as an "entrypoint" to the module.

When called this way, parameters passed to `entry` functions must be inputs to the transaction block, not the results of previous transactions in that block, and not modified by previous transactions in that block. Entry functions are also only allowed to return types that have `drop`.

These restrictions prevent third parties using the scriptable nature of programmable transaction blocks to bypass the fact that `entry` functions are not otherwise allowed to be called from other modules.

## `public` vs `entry` functions

The `public` modifier also allows a function to be called from a programmable transaction block.  It additionally allows the function to be called from other modules, and does not impose the same restrictions on where the function's parameters can come from and what it can return, so in many cases `public` is the right way to expose your function to the outside world. `entry` is useful if:

- You want strong guarantees that your function is not being combined with third-party module functions, in programmable transaction blocks.  The canonical example of this is a swap protocol that does not want to interact with a flash loan provider: If the swap protocol exposes only `entry` functions to perform swaps, it will not be possible to pass in a flash loaned `Coin`, because that coin will be the output of some previous transaction.
- You do not want the function's signature to appear in your module's ABI.  `public` function signatures must be maintained by upgrades while `entry` function signatures do not.

It is also possible to create a `public entry` function, which can be called by other modules and by programmable transaction blocks but is restricted like an `entry` function in the latter case.  This is rarely useful -- you probably only want one of `public` or `entry`.

## Example

```move
module entry_functions::example {
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    struct Foo has key {
        id: UID,
        bar: u64,
    }

    /// Entry functions can accept a reference to the `TxContext`
    /// (mutable or immutable) as their last parameter.
    entry fun share(bar: u64, ctx: &mut TxContext) {
        transfer::share_object(Foo {
            id: object::new(ctx),
            bar,
        })
    }

    /// Parameters passed to entry functions called in a programmable
    /// transaction block (like `foo`, below) must be inputs to the
    /// transaction block, and not results of previous transactions.
    entry fun update(foo: &mut Foo, ctx: &TxContext) {
        foo.bar = tx_context::epoch(ctx);
    }

    /// Entry functions can return types that have `drop`.
    entry fun bar(foo: &Foo): u64 {
        foo.bar
    }

    /// This function cannot be `entry` because it returns a value
    /// that does not have `drop`.
    public fun foo(ctx: &mut TxContext): Foo {
        Foo { id: object::new(ctx), bar: 0 }
    }
}
```
